package com.xm;

import com.xm.util.StringUtil;
import jakarta.servlet.http.HttpServlet;

import java.security.cert.Extension;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

/**
 * List：有序可重复，选 ArrayList（随机访问）或 LinkedList（插入删除）。
 *   ArrayList 数组
 *   LinkedList 双向链表
 *   Vector 数组（线程安全 几乎所有的方法都是用了synchronized关键字修饰来保证线程安全）
 *   CopyOnWriteArrayList
 * Set：唯一元素，选 HashSet（快速查找）或 TreeSet（有序）。
 * Map：键值对，选 HashMap（通用）或 LinkedHashMap（保留顺序）。
 *      HashMap（继承AbstractMap） 哈希表（散列表） 非线程安全，允许null键允许null值
 *      HashTable（继承Dictionary）（性能不如ConcurrentHashMap） 哈希表 线程安全，不允许null键不允许null值
 *          很多方法也都是用了synchronized关键字修饰来保证线程安全
 *      TreeMap（继承AbstractMap） 红黑树 非线程安全，不允许null键允许null值
 *      TreeSet（继承AbstractSet） 基于TreeMap的NavigableMap 非线程安全，不允许null键不允许null值
 * Queue/Deque：选 PriorityQueue（优先级）或 ArrayDeque（双端操作）。
 *      简单队列
 *        LinkedList（FIFO）
 *          特点：基于链表实现，支持队列的基本操作。
 *          使用场景：简单的FIFO队列需求
 *        ArrayQueue（FIFO）
 *          特点：基于循环数组实现，性能比LinkedList更高
 *          使用场景：高频队列操作（如算法题中的 BFS）
 *      优先级队列
 *        PriorityQueue
 *          特点：元素按优先级排序（默认最小堆，队头是最小元素）。
 *          使用场景：任务调度、Top K 问题。
 *      双端队列
 *        Deque
 *          特点：支持在队列两端插入和删除元素。
 *          适用场景：滑动窗口算法、实现栈和队列。
 *      阻塞队列
 *        BlockingQueue
 *          LinkedBlockingQueue
 *              特点：线程安全，支持阻塞等待（当队列满/空时阻塞操作）。
 *              适用场景：生产者-消费者模型。
 *          ArrayBlockingQueue
 *              特点：固定容量，基于数组实现。
 *      并发队列
 *        ConcurrentLinkedQueue
 *          特点：无界、线程安全的非阻塞队列（基于 CAS 实现）。
 *          适用场景：高并发环境下的任务队列。
 *      延迟队列
 *        DelayQueue
 *          特点：元素在指定延迟时间后才能被取出。
 *          适用场景：定时任务调度、缓存过期。
 */
public class TestMe {
    public static void main(String[] args) {
        //工厂模式：返回不可修改的集合，隐藏具体实现类
//        List<String> list = Collections.unmodifiableList(new ArrayList<String>());
//        list.add("123");
//        System.out.println(list);
//        ArrayList
//        LinkedList
//        Vector<String> v = new Vector<>();
//        v.add("123");
//        ConcurrentHashMap<String, Object> map = new ConcurrentHashMap<>();
//        map.put("123", v);
//        LinkedList<String> linkedList = new LinkedList<>();

        System.out.println(Runtime.getRuntime().availableProcessors() * 2);

        StringBuilder builder = new StringBuilder();
        builder.append("Hello World");

        StringBuffer buffer = new StringBuffer();
        buffer.append("Hello World");

        List<Integer> list = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
        List<List<?>> lists = StringUtil.groupBatchSize(list, 3);
        System.out.println(lists);

//        ClassLoader //双亲委派模型，优先加载父类

//        HttpServlet

    }

}
